home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 1.iso / toolbox / src / demos / OpenGL / stonehenge / main.c++ < prev    next >
Encoding:
C/C++ Source or Header  |  1996-11-11  |  11.7 KB  |  335 lines
  1. /*
  2.  * (c) Copyright 1993, Silicon Graphics, Inc.
  3.  * ALL RIGHTS RESERVED
  4.  *
  5.  * Permission to use, copy, modify, and distribute this software for
  6.  * any purpose and without fee is hereby granted, provided that the above
  7.  * copyright notice appear in all copies and that both the copyright notice
  8.  * and this permission notice appear in supporting documentation, and that
  9.  * the name of Silicon Graphics, Inc. not be used in advertising
  10.  * or publicity pertaining to distribution of the software without specific,
  11.  * written prior permission.
  12.  *
  13.  * THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"
  14.  * AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,
  15.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR
  16.  * FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL SILICON
  17.  * GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,
  18.  * SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
  19.  * KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,
  20.  * LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF
  21.  * THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC.  HAS BEEN
  22.  * ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
  23.  * ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
  24.  * POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
  25.  *
  26.  * U.S. GOVERNMENT RESTRICTED RIGHTS LEGEND
  27.  * Use, duplication, or disclosure by the Government is subject to
  28.  * restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
  29.  * (c)(1)(ii) of the Rights in Technical Data and Computer Software
  30.  * clause at DFARS 252.227-7013 and/or in similar or successor
  31.  * clauses in the FAR or the DOD or NASA FAR Supplement.
  32.  * Unpublished-- rights reserved under the copyright laws of the
  33.  * United States.  Contractor/manufacturer is Silicon Graphics,
  34.  * Inc., 2011 N.  Shoreline Blvd., Mountain View, CA 94039-7311.
  35.  *
  36.  * OpenGL(TM) is a trademark of Silicon Graphics, Inc.
  37.  */
  38. #include <GL/glu.h>
  39. #include <GL/glx.h>
  40.  
  41. #include <X11/Intrinsic.h>
  42. #include <Xm/Xm.h>
  43. #include <Xm/CascadeB.h>
  44. #include <Xm/Frame.h>
  45. #include <Xm/MainW.h>
  46. #include <Xm/PushB.h>
  47. #include <Xm/PushBG.h>
  48. #include <Xm/RowColumn.h>
  49. #include <Xm/ToggleB.h>
  50. #include <GL/GLwMDrawA.h>
  51.  
  52. #include <stdio.h>
  53. #include <stdlib.h>
  54.  
  55. #include "atmosphere.h"
  56. #include "scene.h"
  57. #include "callbacks.h"
  58.  
  59. static Display *display;
  60. XtAppContext app_context;
  61. Widget glw;
  62.  
  63. const int max_args = 20;
  64.  
  65. static int speeds[] = {0, 1, 10, 100, 500};
  66.  
  67. XVisualInfo *find_visual() 
  68. {
  69.   int attr[256], i, stencil, dbuffer, accum;
  70.   XVisualInfo *vi;
  71.  
  72.   i = 0;
  73.   attr[i++] = GLX_RGBA;
  74.   attr[i++] = GLX_RED_SIZE;  attr[i++] = 1;
  75.   attr[i++] = GLX_GREEN_SIZE;  attr[i++] = 1;
  76.   attr[i++] = GLX_BLUE_SIZE;  attr[i++] = 1;
  77.   attr[i++] = GLX_DEPTH_SIZE;  attr[i++] = 1;
  78.   dbuffer = i;
  79.   attr[i++] = GLX_DOUBLEBUFFER;
  80.   stencil = i;
  81.   attr[i++] = GLX_STENCIL_SIZE;
  82.   attr[i++] = 1;
  83.   accum = i;
  84.   attr[i++] = GLX_ACCUM_RED_SIZE;  attr[i++] = 1;
  85.   attr[i++] = GLX_ACCUM_BLUE_SIZE;  attr[i++] = 1;
  86.   attr[i++] = GLX_ACCUM_GREEN_SIZE;  attr[i++] = 1;
  87.   attr[i++] = GLX_ACCUM_ALPHA_SIZE;  attr[i++] = 1;
  88.   attr[i++] = (int)None;
  89.  
  90.   vi = glXChooseVisual(display, DefaultScreen(display), attr);
  91.   if (vi == NULL) {
  92.     fprintf(stderr, "Unable to find visual with accumulation buffer.\n");
  93.     fprintf(stderr, "(Fancy fog won't work).\n");
  94.     attr[accum] = (int)None;
  95.     vi = glXChooseVisual(display, DefaultScreen(display), attr);
  96.     if (vi == NULL) {
  97.       fprintf(stderr, "Unable to find visual with stencil buffer.\n");
  98.       fprintf(stderr, "(Things won't look quite as good).\n");
  99.       attr[stencil] = (int)None;
  100.       vi = glXChooseVisual(display, DefaultScreen(display), attr);
  101.       if (vi == NULL) {
  102.     fprintf(stderr, "Unable to find double-buffered visual.\n");
  103.     fprintf(stderr, "(Things will look even worse).\n");
  104.     attr[dbuffer] = (int)None;
  105.     vi = glXChooseVisual(display, DefaultScreen(display), attr);
  106.     if (vi == NULL) fprintf(stderr, "Can't find visual at all.\n");
  107.       }
  108.     }
  109.   }
  110.   return vi;
  111. }
  112.  
  113. Widget create_widgets(Widget parent)
  114. {
  115.   Widget main_window;
  116.   Widget menu_bar;
  117.   Widget menu_pane; 
  118.   Widget button;
  119.   Widget cascade;
  120.   Widget frame;
  121.   XVisualInfo *vi;
  122.  
  123.   Arg args[max_args];
  124.   int argcount;
  125.  
  126.   char buffer[128];
  127.  
  128.   int i;
  129.  
  130.   main_window = XmCreateMainWindow(parent, "main1", NULL, 0);
  131.   XtManageChild(main_window);
  132.  
  133.   menu_bar = XmCreateMenuBar(main_window, "menu_bar", NULL, 0);
  134.   XtManageChild(menu_bar);
  135.     
  136.   menu_pane = XmCreatePulldownMenu(menu_bar, "menu_pane", NULL, 0);
  137.   button = XmCreatePushButton(menu_pane, "Exit", NULL, 0);
  138.   XtManageChild(button);
  139.   XtAddCallback(button, XmNactivateCallback, (XtCallbackProc)exitCB, NULL);
  140.       
  141.   XtSetArg(args[0], XmNsubMenuId, menu_pane);
  142.   cascade = XmCreateCascadeButton(menu_bar, "File", args, 1);
  143.   XtManageChild(cascade);
  144.  
  145.  
  146.  
  147.   menu_pane = XmCreatePulldownMenu(menu_bar, "menu_pane", NULL, 0);
  148.   XtSetArg(args[0], XmNset, use_lighting);
  149.   button = XmCreateToggleButton(menu_pane, "Lighting", args, 1);
  150.   XtManageChild(button);
  151.   XtAddCallback(button, XmNvalueChangedCallback, 
  152.                 (XtCallbackProc)intToggleCB, &use_lighting);
  153.   XtSetArg(args[0], XmNset, draw_shadows);
  154.   button = XmCreateToggleButton(menu_pane, "Shadows", args, 1);
  155.   XtManageChild(button);
  156.   XtAddCallback(button, XmNvalueChangedCallback, 
  157.                 (XtCallbackProc)intToggleCB, &draw_shadows);
  158.  
  159.  
  160.   XtSetArg(args[0], XmNset, use_normal_fog);
  161.   button = XmCreateToggleButton(menu_pane, "Fog", args, 1);
  162.   XtManageChild(button);
  163.   XtAddCallback(button, XmNvalueChangedCallback, 
  164.                 (XtCallbackProc)intToggleCB, &use_normal_fog);
  165.  
  166. #ifdef TEXTURE
  167.   XtSetArg(args[0], XmNset, use_textures);
  168.   button = XmCreateToggleButton(menu_pane, "Texture Map", args, 1);
  169.   XtManageChild(button);
  170.   XtAddCallback(button, XmNvalueChangedCallback, 
  171.                 (XtCallbackProc)intToggleCB, &use_textures);
  172. #endif
  173.  
  174.   XtSetArg(args[0], XmNset, use_telescope);
  175.   button = XmCreateToggleButton(menu_pane, "Telescope", args, 1);
  176.   XtManageChild(button);
  177.   XtAddCallback(button, XmNvalueChangedCallback,
  178.         (XtCallbackProc)intToggleCB, &use_telescope);
  179.  
  180.   XtSetArg(args[0], XmNset, use_antialias);
  181.   button = XmCreateToggleButton(menu_pane, "Antialias", args, 1);
  182.   XtManageChild(button);
  183.   XtAddCallback(button, XmNvalueChangedCallback,
  184.         (XtCallbackProc)intToggleCB, &use_antialias);
  185.  
  186.   XtSetArg(args[0], XmNsubMenuId, menu_pane);
  187.   cascade = XmCreateCascadeButton(menu_bar, "SPFX", args, 1);
  188.   XtManageChild(cascade);
  189.  
  190.  
  191.   argcount = 0;
  192.   XtSetArg(args[argcount], XmNradioBehavior, True); argcount++;
  193.   menu_pane = XmCreatePulldownMenu(menu_bar, "menu_pane", args, argcount);
  194.   XtSetArg(args[0], XmNset, TRUE);
  195.   for (i = 0; i < nweathers; i++) {
  196.     if (i == def_weather_index) argcount = 1;
  197.     else argcount = 0;
  198.     button = XmCreateToggleButton(menu_pane, (char *)weathers[i].name, 
  199.                   args, argcount);
  200.     XtManageChild(button);
  201.     XtAddCallback(button, XmNvalueChangedCallback, 
  202.           (XtCallbackProc)weatherCB,
  203.           (XtPointer)(&weathers[i]));
  204.   }
  205.   XtSetArg(args[0], XmNsubMenuId, menu_pane);
  206.   cascade = XmCreateCascadeButton(menu_bar, "Weather", args, 1);
  207.   XtManageChild(cascade);
  208.  
  209.  
  210.   argcount = 0;
  211.   XtSetArg(args[argcount], XmNradioBehavior, True); argcount++;
  212.   menu_pane = XmCreatePulldownMenu(menu_bar, "menu_pane", args, argcount);
  213.   button = XmCreatePushButton(menu_pane, "Current Time", NULL, 0);
  214.   XtManageChild(button);
  215.   XtAddCallback(button, XmNactivateCallback, 
  216.         (XtCallbackProc)currentTimeCB, NULL);
  217.   button = XmCreatePushButton(menu_pane, "10 a.m.", NULL, 0);
  218.   XtManageChild(button);
  219.   XtAddCallback(button, XmNactivateCallback, 
  220.         (XtCallbackProc)time10amCB, NULL);
  221.   button = XmCreatePushButton(menu_pane, "Noon", NULL, 0);
  222.   XtManageChild(button);
  223.   XtAddCallback(button, XmNactivateCallback, 
  224.         (XtCallbackProc)time12pmCB, NULL);
  225.   button = XmCreatePushButton(menu_pane, "4 p.m.", NULL, 0);
  226.   XtManageChild(button);
  227.   XtAddCallback(button, XmNactivateCallback, 
  228.         (XtCallbackProc)time4pmCB, NULL);
  229.  
  230.   XtSetArg(args[0], XmNset, 1); argcount = 1;
  231.   button = XmCreateToggleButton(menu_pane, "Hold Time", args, 1);
  232.   XtManageChild(button);
  233.   XtAddCallback(button, XmNvalueChangedCallback,
  234.         (XtCallbackProc)timeSpeedCB, &speeds[0]);
  235.   button = XmCreateToggleButton(menu_pane, "Scale = 1:1", NULL, 0);
  236.   XtManageChild(button);
  237.   XtAddCallback(button, XmNvalueChangedCallback,
  238.         (XtCallbackProc)timeSpeedCB, &speeds[1]);
  239.   button = XmCreateToggleButton(menu_pane, "Scane = 1:10", NULL, 0);
  240.   XtManageChild(button);
  241.   XtAddCallback(button, XmNvalueChangedCallback,
  242.         (XtCallbackProc)timeSpeedCB, &speeds[2]);
  243.   button = XmCreateToggleButton(menu_pane, "Scane = 1:100", NULL, 0);
  244.   XtManageChild(button);
  245.   XtAddCallback(button, XmNvalueChangedCallback,
  246.         (XtCallbackProc)timeSpeedCB, &speeds[3]);
  247.   button = XmCreateToggleButton(menu_pane, "Scane = 1:500", NULL, 0);
  248.   XtManageChild(button);
  249.   XtAddCallback(button, XmNvalueChangedCallback,
  250.         (XtCallbackProc)timeSpeedCB, &speeds[4]);  
  251.  
  252.   XtSetArg(args[0], XmNsubMenuId, menu_pane);
  253.   cascade = XmCreateCascadeButton(menu_bar, "Time", args, 1);
  254.   XtManageChild(cascade);
  255.  
  256.  
  257.   menu_pane = XmCreatePulldownMenu(menu_bar, "menu_pane", NULL, 0);
  258.   XtSetArg(args[0], XmNset, cb_demo_mode); argcount = 1;
  259.   button = XmCreateToggleButton(menu_pane, "Demo Mode", args, 1);
  260.   XtManageChild(button);
  261.   XtAddCallback(button, XmNvalueChangedCallback,
  262.         (XtCallbackProc)demo_modeCB, (XtPointer)0);
  263.   button = XmCreatePushButton(menu_pane, "Reset viewer", NULL, 0);
  264.   XtManageChild(button);
  265.   XtAddCallback(button, XmNactivateCallback, 
  266.         (XtCallbackProc)resetViewerCB, NULL);
  267.   XtSetArg(args[0], XmNsubMenuId, menu_pane);
  268.   cascade = XmCreateCascadeButton(menu_bar, "Misc", args, 1);
  269.   XtManageChild(cascade);
  270.  
  271.  
  272.   argcount = 0;
  273.   XtSetArg(args[argcount], XmNmarginWidth, 0); argcount++;
  274.   XtSetArg(args[argcount], XmNmarginHeight, 0); argcount++;
  275.   XtSetArg(args[argcount], XmNshadowThickness, 1); argcount++;
  276.   XtSetArg(args[argcount], XmNshadowType, XmSHADOW_OUT); argcount++;
  277.   frame = XmCreateFrame(main_window, "frame", args, argcount);
  278.   XtManageChild(frame);
  279.  
  280.   argcount = 0;
  281.   vi = find_visual();
  282.   if (vi) {
  283.     XtSetArg(args[argcount], GLwNvisualInfo, vi); argcount++;
  284.   }
  285.   else {
  286.     XtSetArg(args[argcount], GLwNrgba, TRUE); argcount++;
  287.     XtSetArg(args[argcount], GLwNdepthSize, 1); argcount++;
  288.     XtSetArg(args[argcount], GLwNdoublebuffer, TRUE); argcount++;
  289.   }
  290.   XtSetArg(args[argcount], XmNbottomAttachment, XmATTACH_FORM); argcount++;
  291.   XtSetArg(args[argcount], XmNtopAttachment, XmATTACH_FORM); argcount++;
  292.   XtSetArg(args[argcount], XmNleftAttachment, XmATTACH_FORM); argcount++;
  293.   XtSetArg(args[argcount], XmNrightAttachment, XmATTACH_FORM); argcount++;
  294.   glw = GLwCreateMDrawingArea(frame, "glwidget", args, argcount);
  295.   XtManageChild(glw);
  296.   XtAddCallback(glw, GLwNginitCallback, (XtCallbackProc)initCB, 0);
  297.   XtAddCallback(glw, GLwNexposeCallback, (XtCallbackProc)exposeCB, 0);
  298.   XtAddCallback(glw, GLwNresizeCallback, (XtCallbackProc)resizeCB, 0);
  299.   XtAddCallback(glw, GLwNinputCallback, (XtCallbackProc)inputCB, 0);
  300.  
  301.   return main_window;
  302. }
  303.  
  304. void main(int argc, char **argv)
  305. {
  306.   Widget app_shell;
  307.   Arg args[max_args];
  308.   int argcount;
  309.  
  310.   XtToolkitInitialize();
  311.   app_context = XtCreateApplicationContext();
  312.   display = XtOpenDisplay(app_context, NULL, argv[0],
  313.                           "XMdemos", NULL, 0, &argc, argv);
  314.   if (!display) {
  315.     XtWarning("Can't open display.");
  316.     exit(0);
  317.   }
  318.  
  319.   argcount = 0;
  320.   XtSetArg(args[argcount], XmNmaxAspectX, 1); argcount++;
  321.   XtSetArg(args[argcount], XmNmaxAspectY, 1); argcount++;
  322.   XtSetArg(args[argcount], XmNminAspectX, 1); argcount++;
  323.   XtSetArg(args[argcount], XmNminAspectY, 1); argcount++;
  324.   app_shell = 
  325.     XtAppCreateShell(argv[0], "XMdemos", applicationShellWidgetClass,
  326.                      display, args, argcount);
  327.   
  328.   create_widgets(app_shell);
  329.  
  330.   XtRealizeWidget(app_shell);
  331.  
  332.   XtAppMainLoop(app_context);
  333.   
  334. }
  335.